home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 22 / Amiga Format AFCD22 (Jan 1998, Issue 106).iso / -in_the_mag- / converters / graphics / netpbm / hpcdtoppm.0.6 / src / postscr.c < prev    next >
C/C++ Source or Header  |  1997-11-16  |  10KB  |  406 lines
  1. /* hpcdtoppm (Hadmut's pcdtoppm) v0.6
  2. *  Copyright (c) 1992, 1993, 1994 by Hadmut Danisch (danisch@ira.uka.de).
  3. *  Permission to use and distribute this software and its
  4. *  documentation for noncommercial use and without fee is hereby granted,
  5. *  provided that the above copyright notice appear in all copies and that
  6. *  both that copyright notice and this permission notice appear in
  7. *  supporting documentation. It is not allowed to sell this software in 
  8. *  any way. This software is not public domain.
  9. */
  10.  
  11. #include "hpcdtoppm.h"
  12. #define DITH_NEUTR 128
  13.  
  14. FLTPT PAPER_LEFT    =DEF_PAPER_LEFT;
  15. FLTPT PAPER_BOTTOM  =DEF_PAPER_BOTTOM;
  16. FLTPT PAPER_WIDTH   =DEF_PAPER_WIDTH;
  17. FLTPT PAPER_HEIGHT  =DEF_PAPER_HEIGHT;
  18. FLTPT PRINTER_XDPI  =DEF_DPI;
  19. FLTPT PRINTER_YDPI  =DEF_DPI;
  20. FLTPT PRINTER_FAK   =1.0;
  21. sINT  PSIZE_SET=0,DPI_SET=0,FAK_SET=0;
  22.  
  23.  
  24. static char pshdr[]="%%Creator: hpcdtoppm v0.6\n";
  25. static char hex[]="0123456789ABCDEF";
  26. #define HEX(x) {fputc(hex[((x)>>4)&0xf],fout);fputc(hex[(x)&0xf],fout);}
  27.  
  28.  
  29. /* find an appropriate scaling coefficient and generate a ps header
  30.  * including a BoundingBox comment and a translate/scale sequence to 
  31.  * fit the pixw*pixh image into a square on paper with PS user coordinates 
  32.  * x,y,w,h 
  33.  */
  34. static void size_dependant(FILE *fout,sINT pixw,sINT pixh,
  35.                            FLTPT x,FLTPT y,FLTPT w,FLTPT h)
  36. { FLTPT scale=(FLTPT)w/pixw,scaley=(FLTPT)h/pixh;
  37.  
  38.   if(scale>scaley) scale=scaley;
  39.   x+=w/2.0;y+=h/2.0;
  40.   fprintf(fout,"%%%%BoundingBox: %.8g %.8g %.8g %.8g\n",
  41.      x-scale*pixw/2.0,y-scale*pixh/2.0,
  42.      x+scale*pixw/2.0,y+scale*pixh/2.0);
  43.   fprintf(fout,"%s",pshdr);
  44.   fputs("%%Pages: 1 1\n",fout);
  45.  
  46.   if(pcdname) fprintf(fout,"%%%%Title: %s\n",pcdname);
  47.   fputs("%%EndComments\n\n",fout);
  48.  
  49.   fprintf(fout,"%f %f translate\n",x-scale*pixw/2.0,y-scale*pixh/2.0);
  50.   fprintf(fout,"%f %f scale\n",scale*pixw,scale*pixh);
  51. }
  52.  
  53.  
  54.  
  55. static void end_postscript(FILE *fout)
  56.  {
  57.   fputs("%%EOF\n\n",fout);
  58.  }
  59.  
  60.  
  61.  
  62.  
  63. static void sub_psgrey(FILE *fout,dim w,dim h, uBYTE *ptr,sdim zeil,sdim pix)
  64. { dim x,y;
  65.   register uBYTE *p;
  66.   sINT c;
  67.  
  68.   size_dependant(fout,w,h,PAPER_LEFT,PAPER_BOTTOM,PAPER_WIDTH,PAPER_HEIGHT);
  69.   fprintf(fout,"%d string\n",w);
  70.   fprintf(fout,"%d %d 8\n",w,h);    /* always 8 bit per channel */
  71.   fprintf(fout,"[%d 0 0 %d 0 %d]\n",w,-h,h);
  72.   fputs("{currentfile 1 index readhexstring pop} image\n",fout);
  73.   
  74.   c=0;
  75.   for(y=0;y<h;y++,ptr+=zeil)
  76.     for(p=ptr,x=0;x<w;x++,p+=pix)
  77.       {HEX(*p);
  78.        if(!(++c % 36)) fputs("\n",fout);
  79.       }
  80.  
  81.   fputs("\npop\n\n",fout);
  82. }
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90. void write_epsgrey(FILE *fout,dim w,dim h, uBYTE *ptr,sdim zeil,sdim pix)
  91. { 
  92.   fputs("%!PS-Adobe-2.0 EPSF-2.0\n",fout);
  93.   sub_psgrey(fout,w,h, ptr,zeil,pix);
  94.   end_postscript(fout);
  95. }
  96.  
  97. void write_psgrey(FILE *fout,dim w,dim h, uBYTE *ptr,sdim zeil,sdim pix)
  98. { 
  99.   fputs("%!PS-Adobe-2.0\n",fout);
  100.   sub_psgrey(fout,w,h, ptr,zeil,pix);
  101.   fputs("showpage\n",fout);
  102.   end_postscript(fout);
  103. }
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115. static void sub_psrgb(FILE *fout,dim w,dim h, 
  116.                       uBYTE *rptr,sdim rzeil,sdim rpix,  
  117.               uBYTE *gptr,sdim gzeil,sdim gpix,  
  118.               uBYTE *bptr,sdim bzeil,sdim bpix) 
  119. { dim x,y;
  120.   register uBYTE *pr,*pg,*pb;
  121.   sINT c;
  122.  
  123.   size_dependant(fout,w,h,PAPER_LEFT,PAPER_BOTTOM,PAPER_WIDTH,PAPER_HEIGHT);
  124.   fprintf(fout,"%d string\n",w*3);
  125.   fprintf(fout,"%d %d 8\n",w,h);    /* always 8 bit per channel */
  126.   fprintf(fout,"[%d 0 0 %d 0 %d]\n",w,-h,h);
  127.   fputs("{currentfile 1 index readhexstring pop} false 3 colorimage\n",fout);
  128.   
  129.   c=0; 
  130.   for(y=0;y<h;y++,rptr+=rzeil,gptr+=gzeil,bptr+=bzeil)
  131.     for(pr=rptr,pg=gptr,pb=bptr,x=0;x<w;x++,pr+=rpix,pg+=gpix,pb+=bpix)
  132.       {HEX(*pr);HEX(*pg);HEX(*pb);
  133.        if(!(++c % 12)) fputs("\n",fout);
  134.       }
  135.  
  136.   fputs("\npop\n\n",fout);
  137. }
  138.  
  139.  
  140. void write_epsrgb(FILE *fout,dim w,dim h, 
  141.                       uBYTE *rptr,sdim rzeil,sdim rpix,  
  142.               uBYTE *gptr,sdim gzeil,sdim gpix,  
  143.               uBYTE *bptr,sdim bzeil,sdim bpix) 
  144. { 
  145.   fputs("%!PS-Adobe-2.0 EPSF-2.0\n",fout);
  146.   sub_psrgb(fout,w,h, rptr,rzeil,rpix,gptr,gzeil,gpix,bptr,bzeil,bpix);
  147.   end_postscript(fout);
  148. }
  149.  
  150.  
  151.  
  152. void write_psrgb(FILE *fout,dim w,dim h, 
  153.                       uBYTE *rptr,sdim rzeil,sdim rpix,  
  154.               uBYTE *gptr,sdim gzeil,sdim gpix,  
  155.               uBYTE *bptr,sdim bzeil,sdim bpix) 
  156. { 
  157.   fputs("%!PS-Adobe-2.0\n",fout);
  158.   sub_psrgb(fout,w,h, rptr,rzeil,rpix,gptr,gzeil,gpix,bptr,bzeil,bpix);
  159.   fputs("showpage\n",fout);
  160.   end_postscript(fout);
  161. }
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171. typedef sINT dt;
  172. extern sINT dithtab[];
  173. #define DS 4
  174. #define DA (1<<(DS-1))
  175. #define DT 127
  176.  
  177. static void fakcopy(dim worig,dim horig, uBYTE *ptr1,sdim zeil,sdim pix,
  178.                     sdim wx,sINT zn,dt *dest)
  179.  {FLTPT owf,ohf,wbruch,hbruch,m1,m2,ha,hb;
  180.   dim   owd,ohd,x;
  181.   uBYTE *ptr2;
  182.   sINT  md;
  183.   
  184.   ohf=zn/PRINTER_FAK;
  185.   ohd=(dim)ohf;
  186.   hbruch=ohf-(FLTPT)ohd;
  187.   if(ohd>=horig) error(E_INTERN);
  188.  
  189.   ptr1+=zeil*ohd;
  190.   ptr2= (ohd < horig - 1) ? ptr1+zeil : ptr1;
  191.  
  192.   dest[-1]=DITH_NEUTR;
  193.  
  194.   for(x=0;x<wx;x++)
  195.    {owf=x/PRINTER_FAK;
  196.     owd=(dim)owf;
  197.     wbruch=owf-(FLTPT)owd;
  198.     if(owd>=worig) error(E_INTERN);
  199.  
  200.     if(owd<worig-1)
  201.      {ha=(FLTPT)ptr1[owd*pix];
  202.       hb=(FLTPT)ptr1[(owd+1)*pix];
  203.       m1=ha+wbruch*(hb-ha);
  204.  
  205.       ha=(FLTPT)ptr2[owd*pix];
  206.       hb=(FLTPT)ptr2[(owd+1)*pix];
  207.       m2=ha+wbruch*(hb-ha);
  208.      }
  209.     else
  210.      { m1=(FLTPT)ptr1[owd*pix];
  211.        m2=(FLTPT)ptr2[owd*pix];
  212.      }
  213.     md=(sINT)(m1+hbruch*(m2-m1));
  214.     if(md<0 || md>255) {fprintf(stderr,"md %d\n",md); error(E_INTERN);}
  215.     *(dest++)=dithtab[md];
  216.  
  217.    }
  218.   
  219.   dest[0]=DITH_NEUTR;
  220.  }
  221.  
  222. static void sub_psdith(FILE *fout,dim worig,dim horig, uBYTE *ptr,sdim zeil,sdim pix)
  223. { register uBYTE *p;
  224.   sINT c,i,ii,j,reg,bit;
  225.   dt new,diff;
  226.   dt *dP1,*dP2,*akt,*nex,*help,*rrun;
  227.   dim ww=0,wl=0,wr=0,hh=0,ho=0,hu=0,wx=0,hx=0;
  228.   int ccase;
  229.   FLTPT PW=0.0,PH=0.0;
  230.  
  231. #define copy(n,d) {if(FAK_SET) fakcopy(worig,horig,ptr,zeil,pix,wx,n,d); \
  232.                    else{p=ptr+((n)*zeil); rrun=d;\
  233.                         for(ii=0;ii<wx;ii++,p+=pix,rrun++) *rrun = dithtab[*p]; \
  234.                         d[-1]=d[wx]=DITH_NEUTR; }}
  235.  
  236.  
  237. #define pr(x) { reg= (reg<<1) | x; bit++;    \
  238.      if(bit==8) {HEX(reg);   \
  239.                  if(!(++c % 36)) fputs("\n",fout);\
  240.                  bit=reg=0;}}
  241.  
  242. #define flush { while(bit) pr(1); }
  243. #define fill pr(1)
  244.  
  245.  
  246.  
  247. #define MakeFit(wi,he) {  ww=(wi+7) & (~7);   wl=(ww-wi)/2;  wr=ww-wi-wl; \
  248.                           hh=(he+7) & (~7);   ho=(hh-he)/2;  hu=hh-he-ho; }
  249.  
  250.  
  251.   
  252.   ccase=( FAK_SET   ? 4 : 0 ) |
  253.         ( DPI_SET   ? 2 : 0 ) |
  254.         ( PSIZE_SET ? 1 : 0 ) ;
  255.  
  256.  
  257.   switch (ccase)
  258.    {case 0: /*  no option or -dpi option */
  259.     case 2: hx=horig;
  260.             wx=worig;
  261.             MakeFit(wx,hx);
  262.             PW=ww*72.0/PRINTER_XDPI;
  263.             PH=hh*72.0/PRINTER_YDPI;
  264.             break;
  265.  
  266.     case 1: /* paper size set with -pw and/or -ph */
  267.             hx=horig;
  268.             wx=worig;
  269.             MakeFit(wx,hx);
  270.             PW=PAPER_WIDTH;
  271.             PH=PAPER_HEIGHT;
  272.             break;
  273.  
  274.     case 6: /* -fak option (and perhaps -dpi) */
  275.     case 4: hx=PRINTER_FAK*horig+0.5;
  276.             wx=PRINTER_FAK*worig+0.5;
  277.             MakeFit(wx,hx);
  278.             PW=ww*72.0/PRINTER_XDPI;
  279.             PH=hh*72.0/PRINTER_YDPI; 
  280.             break;
  281.  
  282.     case 5: /* -fak and papersize */
  283.             hx=PRINTER_FAK*horig+0.5;
  284.             wx=PRINTER_FAK*worig+0.5;
  285.             MakeFit(wx,hx);
  286.             PW=PAPER_WIDTH;
  287.             PH=PAPER_HEIGHT;
  288.             break;
  289.  
  290.     case 3: /* papersize and dpi set, probably the most important case */
  291.             PW=PAPER_WIDTH;
  292.             PH=PAPER_HEIGHT;
  293.  
  294.             FAK_SET=1;
  295.             {FLTPT fw,fh;
  296.              fw=PW/72.0*PRINTER_XDPI/worig;
  297.              fh=PH/72.0*PRINTER_YDPI/horig;
  298.              PRINTER_FAK=MIN(fw,fh);
  299.             }
  300.             hx=PRINTER_FAK*horig+0.5;
  301.             wx=PRINTER_FAK*worig+0.5;
  302.             MakeFit(wx,hx);
  303.             PW=ww*72.0/PRINTER_XDPI;
  304.             PH=hh*72.0/PRINTER_YDPI; 
  305.             break;
  306.  
  307.  
  308.     case 7: /* size, dpi and factor set, this case should have been
  309.                cought earlier... */
  310.     default: error(E_INTERN);
  311.    };
  312.  
  313.   if(FAK_SET && (PRINTER_FAK<=0.0  || PRINTER_FAK >=1000.0)) error(E_PRPAR);
  314.   if(PW<=0.0 || PH<=0.0) error(E_PRPAR);
  315.  
  316.   if(wx < 4 || hx < 4) error(E_PRPAR);
  317.  
  318.  
  319.   if (!(dP1=(dt *)malloc((wx+2)*sizeof(dt)))) error(E_MEM);
  320.   if (!(dP2=(dt *)malloc((wx+2)*sizeof(dt)))) error(E_MEM);
  321.  
  322.  
  323.  
  324.   size_dependant(fout,ww,hh,PAPER_LEFT,PAPER_BOTTOM,PW,PH);
  325.  
  326.   fprintf(fout,"%d string\n",ww);
  327.   fprintf(fout,"%d %d 1\n",ww,hh);    /* always 8 bit per channel */
  328.   fprintf(fout,"[%d 0 0 %d 0 %d]\n",ww,-hh,hh);
  329.   fputs("{currentfile 1 index readhexstring pop} image\n",fout);
  330.   
  331.   c=bit=reg=0;
  332.   akt=dP1+1;
  333.   nex=dP2+1;
  334.  
  335.   for(i=0;i<ho;i++)
  336.     for(j=0;j<ww;j++)
  337.       fill;
  338.  
  339.   copy(0,nex);
  340.   for(i=0;i<hx;i++)
  341.    {help=akt; akt=nex; nex=help;
  342.     if(i<hx-1) copy(i+1,nex);
  343.  
  344.     if(i&1)
  345.       for(j=0;j<wx;j++)
  346.        { new=akt[j]>DT ? 255 : 0;
  347.          diff = akt[j]-new;
  348.          akt[j]=new;
  349.          akt[j+1]+=(diff*7 + DA)>>DS;
  350.          nex[j+1]+=(diff   + DA)>>DS;
  351.          nex[j  ]+=(diff*5 + DA)>>DS;
  352.          nex[j-1]+=(diff*3 + DA)>>DS;
  353.        }
  354.     else
  355.       for(j=wx-1;j>=0;j--)
  356.        { new=akt[j]>DT ? 255 : 0;
  357.          diff = akt[j]-new;
  358.          akt[j]=new;
  359.          akt[j-1]+=(diff*7 + DA)>>DS;
  360.          nex[j-1]+=(diff   + DA)>>DS;
  361.          nex[j  ]+=(diff*5 + DA)>>DS;
  362.          nex[j+1]+=(diff*3 + DA)>>DS;
  363.        }
  364.  
  365.  
  366.     for(j=0;j<wl;j++) fill;
  367.  
  368.     for(j=0;j<wx;j++)
  369.      {if (akt[j]>DT) { pr(1); }
  370.       else           { pr(0); }
  371.      }
  372.  
  373.     for(j=0;j<wr;j++) fill;
  374.  
  375.     flush;
  376.    }
  377.  
  378.   for(i=0;i<hu;i++)
  379.     for(j=0;j<ww;j++)
  380.       fill;
  381.   flush;
  382.  
  383.   fputs("\npop\n\n",fout);
  384.   free(dP1);
  385.   free(dP2);
  386. }
  387.  
  388.  
  389. void write_epsdith(FILE *fout,dim w,dim h, uBYTE *ptr,sdim zeil,sdim pix)
  390. { 
  391.   fputs("%!PS-Adobe-2.0 EPSF-2.0\n",fout);
  392.   sub_psdith(fout,w,h, ptr,zeil,pix);
  393.   end_postscript(fout);
  394. }
  395.  
  396. void write_psdith(FILE *fout,dim w,dim h, uBYTE *ptr,sdim zeil,sdim pix)
  397. { 
  398.   fputs("%!PS-Adobe-2.0\n",fout);
  399.   sub_psdith(fout,w,h, ptr,zeil,pix);
  400.   fputs("showpage\n",fout);
  401.   end_postscript(fout);
  402. }
  403.  
  404.  
  405.  
  406.